Merge branch 'develop' of https://github.com/beego/beego into orm-mock

2021-01-12 21:02:57 +08:00 · 2021-01-12 21:02:57 +08:00 · bd8f4059e4
commit bd8f4059e4
parent deda13f3e4 8cd3acfe7b
7 changed files with 1021 additions and 44 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -9,4 +9,5 @@
 - Fix 4383: ORM Adapter produces panic when using orm.RegisterModelWithPrefix. [4386](https://github.com/beego/beego/pull/4386)
 - Support 4144: Add new api for order by for supporting multiple way to query [4294](https://github.com/beego/beego/pull/4294)
 - Support session Filter chain. [4404](https://github.com/beego/beego/pull/4404)
+- Feature issue #4402 finish router get example. [4416](https://github.com/beego/beego/pull/4416)
 - Implement context.Context support and deprecate `QueryM2MWithCtx` and `QueryTableWithCtx` [4424](https://github.com/beego/beego/pull/4424)
--- a/server/web/namespace.go
+++ b/server/web/namespace.go
@ -187,6 +187,54 @@ func (n *Namespace) Include(cList ...ControllerInterface) *Namespace {
 	return n
 }

+// RouterGet same as beego.RouterGet
+func (n *Namespace) RouterGet(rootpath string, f interface{}) *Namespace {
+	n.handlers.RouterGet(rootpath, f)
+	return n
+}
+
+// RouterPost same as beego.RouterPost
+func (n *Namespace) RouterPost(rootpath string, f interface{}) *Namespace {
+	n.handlers.RouterPost(rootpath, f)
+	return n
+}
+
+// RouterDelete same as beego.RouterDelete
+func (n *Namespace) RouterDelete(rootpath string, f interface{}) *Namespace {
+	n.handlers.RouterDelete(rootpath, f)
+	return n
+}
+
+// RouterPut same as beego.RouterPut
+func (n *Namespace) RouterPut(rootpath string, f interface{}) *Namespace {
+	n.handlers.RouterPut(rootpath, f)
+	return n
+}
+
+// RouterHead same as beego.RouterHead
+func (n *Namespace) RouterHead(rootpath string, f interface{}) *Namespace {
+	n.handlers.RouterHead(rootpath, f)
+	return n
+}
+
+// RouterOptions same as beego.RouterOptions
+func (n *Namespace) RouterOptions(rootpath string, f interface{}) *Namespace {
+	n.handlers.RouterOptions(rootpath, f)
+	return n
+}
+
+// RouterPatch same as beego.RouterPatch
+func (n *Namespace) RouterPatch(rootpath string, f interface{}) *Namespace {
+	n.handlers.RouterPatch(rootpath, f)
+	return n
+}
+
+// Any same as beego.RouterAny
+func (n *Namespace) RouterAny(rootpath string, f interface{}) *Namespace {
+	n.handlers.RouterAny(rootpath, f)
+	return n
+}
+
 // Namespace add nest Namespace
 // usage:
 // ns := beego.NewNamespace(“/v1”).
@ -366,6 +414,62 @@ func NSPatch(rootpath string, f FilterFunc) LinkNamespace {
 	}
 }

+// NSRouterGet call Namespace RouterGet
+func NSRouterGet(rootpath string, f interface{}) LinkNamespace {
+	return func(ns *Namespace) {
+		ns.RouterGet(rootpath, f)
+	}
+}
+
+// NSRouterPost call Namespace RouterPost
+func NSRouterPost(rootpath string, f interface{}) LinkNamespace {
+	return func(ns *Namespace) {
+		ns.RouterPost(rootpath, f)
+	}
+}
+
+// NSRouterHead call Namespace RouterHead
+func NSRouterHead(rootpath string, f interface{}) LinkNamespace {
+	return func(ns *Namespace) {
+		ns.RouterHead(rootpath, f)
+	}
+}
+
+// NSRouterPut call Namespace RouterPut
+func NSRouterPut(rootpath string, f interface{}) LinkNamespace {
+	return func(ns *Namespace) {
+		ns.RouterPut(rootpath, f)
+	}
+}
+
+// NSRouterDelete call Namespace RouterDelete
+func NSRouterDelete(rootpath string, f interface{}) LinkNamespace {
+	return func(ns *Namespace) {
+		ns.RouterDelete(rootpath, f)
+	}
+}
+
+// NSRouterAny call Namespace RouterAny
+func NSRouterAny(rootpath string, f interface{}) LinkNamespace {
+	return func(ns *Namespace) {
+		ns.RouterAny(rootpath, f)
+	}
+}
+
+// NSRouterOptions call Namespace RouterOptions
+func NSRouterOptions(rootpath string, f interface{}) LinkNamespace {
+	return func(ns *Namespace) {
+		ns.RouterOptions(rootpath, f)
+	}
+}
+
+// NSRouterPatch call Namespace RouterPatch
+func NSRouterPatch(rootpath string, f interface{}) LinkNamespace {
+	return func(ns *Namespace) {
+		ns.RouterPatch(rootpath, f)
+	}
+}
+
 // NSAutoRouter call Namespace AutoRouter
 func NSAutoRouter(c ControllerInterface) LinkNamespace {
 	return func(ns *Namespace) {
--- a/server/web/namespace_test.go
+++ b/server/web/namespace_test.go
@ -15,6 +15,7 @@
 package web

 import (
+	"fmt"
 	"net/http"
 	"net/http/httptest"
 	"strconv"
@ -23,6 +24,32 @@ import (
 	"github.com/beego/beego/v2/server/web/context"
 )

+const (
+	exampleBody = "hello world"
+
+	nsNamespace     = "/router"
+	nsPath          = "/user"
+	nsNamespacePath = "/router/user"
+)
+
+type ExampleController struct {
+	Controller
+}
+
+func (m ExampleController) Ping() {
+	err := m.Ctx.Output.Body([]byte(exampleBody))
+	if err != nil {
+		fmt.Println(err)
+	}
+}
+
+func (m ExampleController) ping() {
+	err := m.Ctx.Output.Body([]byte("ping method"))
+	if err != nil {
+		fmt.Println(err)
+	}
+}
+
 func TestNamespaceGet(t *testing.T) {
 	r, _ := http.NewRequest("GET", "/v1/user", nil)
 	w := httptest.NewRecorder()
@ -166,3 +193,215 @@ func TestNamespaceInside(t *testing.T) {
 		t.Errorf("TestNamespaceInside can't run, get the response is " + w.Body.String())
 	}
 }
+
+func TestNamespaceRouterGet(t *testing.T) {
+	r, _ := http.NewRequest(http.MethodGet, nsNamespacePath, nil)
+	w := httptest.NewRecorder()
+
+	ns := NewNamespace(nsNamespace)
+	ns.RouterGet(nsPath, ExampleController.Ping)
+	AddNamespace(ns)
+	BeeApp.Handlers.ServeHTTP(w, r)
+	if w.Body.String() != exampleBody {
+		t.Errorf("TestNamespaceRouterGet can't run, get the response is " + w.Body.String())
+	}
+}
+
+func TestNamespaceRouterPost(t *testing.T) {
+	r, _ := http.NewRequest(http.MethodPost, nsNamespacePath, nil)
+	w := httptest.NewRecorder()
+
+	ns := NewNamespace(nsNamespace)
+	ns.RouterPost(nsPath, ExampleController.Ping)
+	AddNamespace(ns)
+	BeeApp.Handlers.ServeHTTP(w, r)
+	if w.Body.String() != exampleBody {
+		t.Errorf("TestNamespaceRouterPost can't run, get the response is " + w.Body.String())
+	}
+}
+
+func TestNamespaceRouterDelete(t *testing.T) {
+	r, _ := http.NewRequest(http.MethodDelete, nsNamespacePath, nil)
+	w := httptest.NewRecorder()
+
+	ns := NewNamespace(nsNamespace)
+	ns.RouterDelete(nsPath, ExampleController.Ping)
+	AddNamespace(ns)
+	BeeApp.Handlers.ServeHTTP(w, r)
+	if w.Body.String() != exampleBody {
+		t.Errorf("TestNamespaceRouterDelete can't run, get the response is " + w.Body.String())
+	}
+}
+
+func TestNamespaceRouterPut(t *testing.T) {
+	r, _ := http.NewRequest(http.MethodPut, nsNamespacePath, nil)
+	w := httptest.NewRecorder()
+
+	ns := NewNamespace(nsNamespace)
+	ns.RouterPut(nsPath, ExampleController.Ping)
+	AddNamespace(ns)
+	BeeApp.Handlers.ServeHTTP(w, r)
+	if w.Body.String() != exampleBody {
+		t.Errorf("TestNamespaceRouterPut can't run, get the response is " + w.Body.String())
+	}
+}
+
+func TestNamespaceRouterHead(t *testing.T) {
+	r, _ := http.NewRequest(http.MethodHead, nsNamespacePath, nil)
+	w := httptest.NewRecorder()
+
+	ns := NewNamespace(nsNamespace)
+	ns.RouterHead(nsPath, ExampleController.Ping)
+	AddNamespace(ns)
+	BeeApp.Handlers.ServeHTTP(w, r)
+	if w.Body.String() != exampleBody {
+		t.Errorf("TestNamespaceRouterHead can't run, get the response is " + w.Body.String())
+	}
+}
+
+func TestNamespaceRouterOptions(t *testing.T) {
+	r, _ := http.NewRequest(http.MethodOptions, nsNamespacePath, nil)
+	w := httptest.NewRecorder()
+
+	ns := NewNamespace(nsNamespace)
+	ns.RouterOptions(nsPath, ExampleController.Ping)
+	AddNamespace(ns)
+	BeeApp.Handlers.ServeHTTP(w, r)
+	if w.Body.String() != exampleBody {
+		t.Errorf("TestNamespaceRouterOptions can't run, get the response is " + w.Body.String())
+	}
+}
+
+func TestNamespaceRouterPatch(t *testing.T) {
+	r, _ := http.NewRequest(http.MethodPatch, nsNamespacePath, nil)
+	w := httptest.NewRecorder()
+
+	ns := NewNamespace(nsNamespace)
+	ns.RouterPatch(nsPath, ExampleController.Ping)
+	AddNamespace(ns)
+	BeeApp.Handlers.ServeHTTP(w, r)
+	if w.Body.String() != exampleBody {
+		t.Errorf("TestNamespaceRouterPatch can't run, get the response is " + w.Body.String())
+	}
+}
+
+func TestNamespaceRouterAny(t *testing.T) {
+	ns := NewNamespace(nsNamespace)
+	ns.RouterAny(nsPath, ExampleController.Ping)
+	AddNamespace(ns)
+
+	for method := range HTTPMETHOD {
+		w := httptest.NewRecorder()
+		r, _ := http.NewRequest(method, nsNamespacePath, nil)
+		BeeApp.Handlers.ServeHTTP(w, r)
+		if w.Body.String() != exampleBody {
+			t.Errorf("TestNamespaceRouterAny can't run, get the response is " + w.Body.String())
+		}
+	}
+}
+
+func TestNamespaceNSRouterGet(t *testing.T) {
+	r, _ := http.NewRequest(http.MethodGet, nsNamespacePath, nil)
+	w := httptest.NewRecorder()
+
+	ns := NewNamespace(nsNamespace)
+	NSRouterGet(nsPath, ExampleController.Ping)(ns)
+	AddNamespace(ns)
+	BeeApp.Handlers.ServeHTTP(w, r)
+	if w.Body.String() != exampleBody {
+		t.Errorf("TestNamespaceNSRouterGet can't run, get the response is " + w.Body.String())
+	}
+}
+
+func TestNamespaceNSRouterPost(t *testing.T) {
+	r, _ := http.NewRequest(http.MethodPost, nsNamespacePath, nil)
+	w := httptest.NewRecorder()
+
+	ns := NewNamespace("/router")
+	NSRouterPost(nsPath, ExampleController.Ping)(ns)
+	AddNamespace(ns)
+	BeeApp.Handlers.ServeHTTP(w, r)
+	if w.Body.String() != exampleBody {
+		t.Errorf("TestNamespaceNSRouterPost can't run, get the response is " + w.Body.String())
+	}
+}
+
+func TestNamespaceNSRouterDelete(t *testing.T) {
+	r, _ := http.NewRequest(http.MethodDelete, nsNamespacePath, nil)
+	w := httptest.NewRecorder()
+
+	ns := NewNamespace(nsNamespace)
+	NSRouterDelete(nsPath, ExampleController.Ping)(ns)
+	AddNamespace(ns)
+	BeeApp.Handlers.ServeHTTP(w, r)
+	if w.Body.String() != exampleBody {
+		t.Errorf("TestNamespaceNSRouterDelete can't run, get the response is " + w.Body.String())
+	}
+}
+
+func TestNamespaceNSRouterPut(t *testing.T) {
+	r, _ := http.NewRequest(http.MethodPut, nsNamespacePath, nil)
+	w := httptest.NewRecorder()
+
+	ns := NewNamespace(nsNamespace)
+	NSRouterPut(nsPath, ExampleController.Ping)(ns)
+	AddNamespace(ns)
+	BeeApp.Handlers.ServeHTTP(w, r)
+	if w.Body.String() != exampleBody {
+		t.Errorf("TestNamespaceNSRouterPut can't run, get the response is " + w.Body.String())
+	}
+}
+
+func TestNamespaceNSRouterHead(t *testing.T) {
+	r, _ := http.NewRequest(http.MethodHead, nsNamespacePath, nil)
+	w := httptest.NewRecorder()
+
+	ns := NewNamespace(nsNamespace)
+	NSRouterHead(nsPath, ExampleController.Ping)(ns)
+	AddNamespace(ns)
+	BeeApp.Handlers.ServeHTTP(w, r)
+	if w.Body.String() != exampleBody {
+		t.Errorf("TestNamespaceNSRouterHead can't run, get the response is " + w.Body.String())
+	}
+}
+
+func TestNamespaceNSRouterOptions(t *testing.T) {
+	r, _ := http.NewRequest(http.MethodOptions, nsNamespacePath, nil)
+	w := httptest.NewRecorder()
+
+	ns := NewNamespace(nsNamespace)
+	NSRouterOptions(nsPath, ExampleController.Ping)(ns)
+	AddNamespace(ns)
+	BeeApp.Handlers.ServeHTTP(w, r)
+	if w.Body.String() != exampleBody {
+		t.Errorf("TestNamespaceNSRouterOptions can't run, get the response is " + w.Body.String())
+	}
+}
+
+func TestNamespaceNSRouterPatch(t *testing.T) {
+	r, _ := http.NewRequest(http.MethodPatch, nsNamespacePath, nil)
+	w := httptest.NewRecorder()
+
+	ns := NewNamespace(nsNamespace)
+	NSRouterPatch("/user", ExampleController.Ping)(ns)
+	AddNamespace(ns)
+	BeeApp.Handlers.ServeHTTP(w, r)
+	if w.Body.String() != exampleBody {
+		t.Errorf("TestNamespaceNSRouterPatch can't run, get the response is " + w.Body.String())
+	}
+}
+
+func TestNamespaceNSRouterAny(t *testing.T) {
+	ns := NewNamespace(nsNamespace)
+	NSRouterAny(nsPath, ExampleController.Ping)(ns)
+	AddNamespace(ns)
+
+	for method := range HTTPMETHOD {
+		w := httptest.NewRecorder()
+		r, _ := http.NewRequest(method, nsNamespacePath, nil)
+		BeeApp.Handlers.ServeHTTP(w, r)
+		if w.Body.String() != exampleBody {
+			t.Errorf("TestNamespaceNSRouterAny can't run, get the response is " + w.Body.String())
+		}
+	}
+}
--- a/server/web/router.go
+++ b/server/web/router.go
@ -20,6 +20,7 @@ import (
 	"net/http"
 	"path"
 	"reflect"
+	"runtime"
 	"strconv"
 	"strings"
 	"sync"
@ -264,11 +265,7 @@ func (p *ControllerRegister) addWithMethodParams(pattern string, c ControllerInt
 	reflectVal := reflect.ValueOf(c)
 	t := reflect.Indirect(reflectVal).Type()

-	route := &ControllerInfo{}
-	route.pattern = pattern
-	route.routerType = routerTypeBeego
-	route.sessionOn = p.cfg.WebConfig.Session.SessionOn
-	route.controllerType = t
+	route := p.createBeegoRouter(t, pattern)
 	route.initialize = func() ControllerInterface {
 		vc := reflect.New(route.controllerType)
 		execController, ok := vc.Interface().(ControllerInterface)
@ -353,6 +350,256 @@ func (p *ControllerRegister) GiveBackContext(ctx *beecontext.Context) {
 	p.pool.Put(ctx)
 }

+// RouterGet add get method
+// usage:
+//    type MyController struct {
+//	     web.Controller
+//    }
+//    func (m MyController) Ping() {
+//	     m.Ctx.Output.Body([]byte("hello world"))
+//    }
+//
+//    RouterGet("/api/:id", MyController.Ping)
+func (p *ControllerRegister) RouterGet(pattern string, f interface{}) {
+	p.AddRouterMethod(http.MethodGet, pattern, f)
+}
+
+// RouterPost add post method
+// usage:
+//    type MyController struct {
+//	     web.Controller
+//    }
+//    func (m MyController) Ping() {
+//	     m.Ctx.Output.Body([]byte("hello world"))
+//    }
+//
+//    RouterPost("/api/:id", MyController.Ping)
+func (p *ControllerRegister) RouterPost(pattern string, f interface{}) {
+	p.AddRouterMethod(http.MethodPost, pattern, f)
+}
+
+// RouterHead add head method
+// usage:
+//    type MyController struct {
+//	     web.Controller
+//    }
+//    func (m MyController) Ping() {
+//	     m.Ctx.Output.Body([]byte("hello world"))
+//    }
+//
+//    RouterHead("/api/:id", MyController.Ping)
+func (p *ControllerRegister) RouterHead(pattern string, f interface{}) {
+	p.AddRouterMethod(http.MethodHead, pattern, f)
+}
+
+// RouterPut add put method
+// usage:
+//    type MyController struct {
+//	     web.Controller
+//    }
+//    func (m MyController) Ping() {
+//	     m.Ctx.Output.Body([]byte("hello world"))
+//    }
+//
+//    RouterPut("/api/:id", MyController.Ping)
+func (p *ControllerRegister) RouterPut(pattern string, f interface{}) {
+	p.AddRouterMethod(http.MethodPut, pattern, f)
+}
+
+// RouterPatch add patch method
+// usage:
+//    type MyController struct {
+//	     web.Controller
+//    }
+//    func (m MyController) Ping() {
+//	     m.Ctx.Output.Body([]byte("hello world"))
+//    }
+//
+//    RouterPatch("/api/:id", MyController.Ping)
+func (p *ControllerRegister) RouterPatch(pattern string, f interface{}) {
+	p.AddRouterMethod(http.MethodPatch, pattern, f)
+}
+
+// RouterDelete add delete method
+// usage:
+//    type MyController struct {
+//	     web.Controller
+//    }
+//    func (m MyController) Ping() {
+//	     m.Ctx.Output.Body([]byte("hello world"))
+//    }
+//
+//    RouterDelete("/api/:id", MyController.Ping)
+func (p *ControllerRegister) RouterDelete(pattern string, f interface{}) {
+	p.AddRouterMethod(http.MethodDelete, pattern, f)
+}
+
+// RouterOptions add options method
+// usage:
+//    type MyController struct {
+//	     web.Controller
+//    }
+//    func (m MyController) Ping() {
+//	     m.Ctx.Output.Body([]byte("hello world"))
+//    }
+//
+//    RouterOptions("/api/:id", MyController.Ping)
+func (p *ControllerRegister) RouterOptions(pattern string, f interface{}) {
+	p.AddRouterMethod(http.MethodOptions, pattern, f)
+}
+
+// RouterAny add all method
+// usage:
+//    type MyController struct {
+//	     web.Controller
+//    }
+//    func (m MyController) Ping() {
+//	     m.Ctx.Output.Body([]byte("hello world"))
+//    }
+//
+//    RouterAny("/api/:id", MyController.Ping)
+func (p *ControllerRegister) RouterAny(pattern string, f interface{}) {
+	p.AddRouterMethod("*", pattern, f)
+}
+
+// AddRouterMethod add http method router
+// usage:
+//    type MyController struct {
+//	     web.Controller
+//    }
+//    func (m MyController) Ping() {
+//	     m.Ctx.Output.Body([]byte("hello world"))
+//    }
+//
+//    AddRouterMethod("get","/api/:id", MyController.Ping)
+func (p *ControllerRegister) AddRouterMethod(httpMethod, pattern string, f interface{}) {
+	httpMethod = p.getUpperMethodString(httpMethod)
+	ct, methodName := getReflectTypeAndMethod(f)
+
+	p.addBeegoTypeRouter(ct, methodName, httpMethod, pattern)
+}
+
+// addBeegoTypeRouter add beego type router
+func (p *ControllerRegister) addBeegoTypeRouter(ct reflect.Type, ctMethod, httpMethod, pattern string) {
+	route := p.createBeegoRouter(ct, pattern)
+	methods := p.getHttpMethodMapMethod(httpMethod, ctMethod)
+	route.methods = methods
+
+	p.addRouterForMethod(route)
+}
+
+// createBeegoRouter create beego router base on reflect type and pattern
+func (p *ControllerRegister) createBeegoRouter(ct reflect.Type, pattern string) *ControllerInfo {
+	route := &ControllerInfo{}
+	route.pattern = pattern
+	route.routerType = routerTypeBeego
+	route.sessionOn = p.cfg.WebConfig.Session.SessionOn
+	route.controllerType = ct
+	return route
+}
+
+// createRestfulRouter create restful router with filter function and pattern
+func (p *ControllerRegister) createRestfulRouter(f FilterFunc, pattern string) *ControllerInfo {
+	route := &ControllerInfo{}
+	route.pattern = pattern
+	route.routerType = routerTypeRESTFul
+	route.sessionOn = p.cfg.WebConfig.Session.SessionOn
+	route.runFunction = f
+	return route
+}
+
+// createHandlerRouter create handler router with handler and pattern
+func (p *ControllerRegister) createHandlerRouter(h http.Handler, pattern string) *ControllerInfo {
+	route := &ControllerInfo{}
+	route.pattern = pattern
+	route.routerType = routerTypeHandler
+	route.sessionOn = p.cfg.WebConfig.Session.SessionOn
+	route.handler = h
+	return route
+}
+
+// getHttpMethodMapMethod based on http method and controller method, if ctMethod is empty, then it will
+// use http method as the controller method
+func (p *ControllerRegister) getHttpMethodMapMethod(httpMethod, ctMethod string) map[string]string {
+	methods := make(map[string]string)
+	// not match-all sign, only add for the http method
+	if httpMethod != "*" {
+
+		if ctMethod == "" {
+			ctMethod = httpMethod
+		}
+		methods[httpMethod] = ctMethod
+		return methods
+	}
+
+	// add all http method
+	for val := range HTTPMETHOD {
+		if ctMethod == "" {
+			methods[val] = val
+		} else {
+			methods[val] = ctMethod
+		}
+	}
+	return methods
+}
+
+// getUpperMethodString get upper string of method, and panic if the method
+// is not valid
+func (p *ControllerRegister) getUpperMethodString(method string) string {
+	method = strings.ToUpper(method)
+	if method != "*" && !HTTPMETHOD[method] {
+		panic("not support http method: " + method)
+	}
+	return method
+}
+
+// get reflect controller type and method by controller method expression
+func getReflectTypeAndMethod(f interface{}) (controllerType reflect.Type, method string) {
+	// check f is a function
+	funcType := reflect.TypeOf(f)
+	if funcType.Kind() != reflect.Func {
+		panic("not a method")
+	}
+
+	// get function name
+	funcObj := runtime.FuncForPC(reflect.ValueOf(f).Pointer())
+	if funcObj == nil {
+		panic("cannot find the method")
+	}
+	funcNameSli := strings.Split(funcObj.Name(), ".")
+	lFuncSli := len(funcNameSli)
+	if lFuncSli == 0 {
+		panic("invalid method full name: " + funcObj.Name())
+	}
+
+	method = funcNameSli[lFuncSli-1]
+	if len(method) == 0 {
+		panic("method name is empty")
+	} else if method[0] > 96 || method[0] < 65 {
+		panic("not a public method")
+	}
+
+	// check only one param which is the method receiver
+	if numIn := funcType.NumIn(); numIn != 1 {
+		panic("invalid number of param in")
+	}
+
+	// check the receiver implement ControllerInterface
+	controllerType = funcType.In(0)
+	_, ok := reflect.New(controllerType).Interface().(ControllerInterface)
+	if !ok {
+		panic(controllerType.String() + " is not implemented ControllerInterface")
+	}
+
+	// check controller has the method
+	_, exists := controllerType.MethodByName(method)
+	if !exists {
+		panic(controllerType.String() + " has no method " + method)
+	}
+
+	return
+}
+
 // Get add get method
 // usage:
 //    Get("/", func(ctx *context.Context){
@ -431,36 +678,18 @@ func (p *ControllerRegister) Any(pattern string, f FilterFunc) {
 //          ctx.Output.Body("hello world")
 //    })
 func (p *ControllerRegister) AddMethod(method, pattern string, f FilterFunc) {
-	method = strings.ToUpper(method)
-	if method != "*" && !HTTPMETHOD[method] {
-		panic("not support http method: " + method)
-	}
-	route := &ControllerInfo{}
-	route.pattern = pattern
-	route.routerType = routerTypeRESTFul
-	route.sessionOn = p.cfg.WebConfig.Session.SessionOn
-	route.runFunction = f
-	methods := make(map[string]string)
-	if method == "*" {
-		for val := range HTTPMETHOD {
-			methods[val] = val
-		}
-	} else {
-		methods[method] = method
-	}
+	method = p.getUpperMethodString(method)
+
+	route := p.createRestfulRouter(f, pattern)
+	methods := p.getHttpMethodMapMethod(method, "")
 	route.methods = methods
-	for k := range methods {
-		p.addToRouter(k, pattern, route)
-	}
+
+	p.addRouterForMethod(route)
 }

 // Handler add user defined Handler
 func (p *ControllerRegister) Handler(pattern string, h http.Handler, options ...interface{}) {
-	route := &ControllerInfo{}
-	route.pattern = pattern
-	route.routerType = routerTypeHandler
-	route.sessionOn = p.cfg.WebConfig.Session.SessionOn
-	route.handler = h
+	route := p.createHandlerRouter(h, pattern)
 	if len(options) > 0 {
 		if _, ok := options[0].(bool); ok {
 			pattern = path.Join(pattern, "?:all(.*)")
@ -492,16 +721,13 @@ func (p *ControllerRegister) AddAutoPrefix(prefix string, c ControllerInterface)
 	controllerName := strings.TrimSuffix(ct.Name(), "Controller")
 	for i := 0; i < rt.NumMethod(); i++ {
 		if !utils.InSlice(rt.Method(i).Name, exceptMethod) {
-			route := &ControllerInfo{}
-			route.routerType = routerTypeBeego
-			route.sessionOn = p.cfg.WebConfig.Session.SessionOn
-			route.methods = map[string]string{"*": rt.Method(i).Name}
-			route.controllerType = ct
 			pattern := path.Join(prefix, strings.ToLower(controllerName), strings.ToLower(rt.Method(i).Name), "*")
 			patternInit := path.Join(prefix, controllerName, rt.Method(i).Name, "*")
 			patternFix := path.Join(prefix, strings.ToLower(controllerName), strings.ToLower(rt.Method(i).Name))
 			patternFixInit := path.Join(prefix, controllerName, rt.Method(i).Name)
-			route.pattern = pattern
+
+			route := p.createBeegoRouter(ct, pattern)
+			route.methods = map[string]string{"*": rt.Method(i).Name}
 			for m := range HTTPMETHOD {
 				p.addToRouter(m, pattern, route)
 				p.addToRouter(m, patternInit, route)
--- a/server/web/router_test.go
+++ b/server/web/router_test.go
@ -16,6 +16,7 @@ package web

 import (
 	"bytes"
+	"fmt"
 	"net/http"
 	"net/http/httptest"
 	"strings"
@ -34,6 +35,13 @@ func (ptc *PrefixTestController) PrefixList() {
 	ptc.Ctx.Output.Body([]byte("i am list in prefix test"))
 }

+type TestControllerWithInterface struct {
+}
+
+func (m TestControllerWithInterface) Ping() {
+	fmt.Println("pong")
+}
+
 type TestController struct {
 	Controller
 }
@ -828,3 +836,161 @@ func TestRouterSessionSet(t *testing.T) {
 	}

 }
+
+func TestRouterRouterGet(t *testing.T) {
+	r, _ := http.NewRequest(http.MethodGet, "/user", nil)
+	w := httptest.NewRecorder()
+
+	handler := NewControllerRegister()
+	handler.RouterGet("/user", ExampleController.Ping)
+	handler.ServeHTTP(w, r)
+	if w.Body.String() != exampleBody {
+		t.Errorf("TestRouterRouterGet can't run")
+	}
+}
+
+func TestRouterRouterPost(t *testing.T) {
+	r, _ := http.NewRequest(http.MethodPost, "/user", nil)
+	w := httptest.NewRecorder()
+
+	handler := NewControllerRegister()
+	handler.RouterPost("/user", ExampleController.Ping)
+	handler.ServeHTTP(w, r)
+	if w.Body.String() != exampleBody {
+		t.Errorf("TestRouterRouterPost can't run")
+	}
+}
+
+func TestRouterRouterHead(t *testing.T) {
+	r, _ := http.NewRequest(http.MethodHead, "/user", nil)
+	w := httptest.NewRecorder()
+
+	handler := NewControllerRegister()
+	handler.RouterHead("/user", ExampleController.Ping)
+	handler.ServeHTTP(w, r)
+	if w.Body.String() != exampleBody {
+		t.Errorf("TestRouterRouterHead can't run")
+	}
+}
+
+func TestRouterRouterPut(t *testing.T) {
+	r, _ := http.NewRequest(http.MethodPut, "/user", nil)
+	w := httptest.NewRecorder()
+
+	handler := NewControllerRegister()
+	handler.RouterPut("/user", ExampleController.Ping)
+	handler.ServeHTTP(w, r)
+	if w.Body.String() != exampleBody {
+		t.Errorf("TestRouterRouterPut can't run")
+	}
+}
+
+func TestRouterRouterPatch(t *testing.T) {
+	r, _ := http.NewRequest(http.MethodPatch, "/user", nil)
+	w := httptest.NewRecorder()
+
+	handler := NewControllerRegister()
+	handler.RouterPatch("/user", ExampleController.Ping)
+	handler.ServeHTTP(w, r)
+	if w.Body.String() != exampleBody {
+		t.Errorf("TestRouterRouterPatch can't run")
+	}
+}
+
+func TestRouterRouterDelete(t *testing.T) {
+	r, _ := http.NewRequest(http.MethodDelete, "/user", nil)
+	w := httptest.NewRecorder()
+
+	handler := NewControllerRegister()
+	handler.RouterDelete("/user", ExampleController.Ping)
+	handler.ServeHTTP(w, r)
+	if w.Body.String() != exampleBody {
+		t.Errorf("TestRouterRouterDelete can't run")
+	}
+}
+
+func TestRouterRouterAny(t *testing.T) {
+	handler := NewControllerRegister()
+	handler.RouterAny("/user", ExampleController.Ping)
+
+	for method := range HTTPMETHOD {
+		w := httptest.NewRecorder()
+		r, _ := http.NewRequest(method, "/user", nil)
+		handler.ServeHTTP(w, r)
+		if w.Body.String() != exampleBody {
+			t.Errorf("TestRouterRouterAny can't run, get the response is " + w.Body.String())
+		}
+	}
+}
+
+func TestRouterAddRouterMethodPanicInvalidMethod(t *testing.T) {
+	method := "some random method"
+	message := "not support http method: " + strings.ToUpper(method)
+	defer func() {
+		err := recover()
+		if err != nil { //产生了panic异常
+			errStr, ok := err.(string)
+			if ok && errStr == message {
+				return
+			}
+		}
+		t.Errorf(fmt.Sprintf("TestRouterAddRouterMethodPanicInvalidMethod failed: %v", err))
+	}()
+
+	handler := NewControllerRegister()
+	handler.AddRouterMethod(method, "/user", ExampleController.Ping)
+}
+
+func TestRouterAddRouterMethodPanicNotAMethod(t *testing.T) {
+	method := http.MethodGet
+	message := "not a method"
+	defer func() {
+		err := recover()
+		if err != nil { //产生了panic异常
+			errStr, ok := err.(string)
+			if ok && errStr == message {
+				return
+			}
+		}
+		t.Errorf(fmt.Sprintf("TestRouterAddRouterMethodPanicNotAMethod failed: %v", err))
+	}()
+
+	handler := NewControllerRegister()
+	handler.AddRouterMethod(method, "/user", ExampleController{})
+}
+
+func TestRouterAddRouterMethodPanicNotPublicMethod(t *testing.T) {
+	method := http.MethodGet
+	message := "not a public method"
+	defer func() {
+		err := recover()
+		if err != nil { //产生了panic异常
+			errStr, ok := err.(string)
+			if ok && errStr == message {
+				return
+			}
+		}
+		t.Errorf(fmt.Sprintf("TestRouterAddRouterMethodPanicNotPublicMethod failed: %v", err))
+	}()
+
+	handler := NewControllerRegister()
+	handler.AddRouterMethod(method, "/user", ExampleController.ping)
+}
+
+func TestRouterAddRouterMethodPanicNotImplementInterface(t *testing.T) {
+	method := http.MethodGet
+	message := "web.TestControllerWithInterface is not implemented ControllerInterface"
+	defer func() {
+		err := recover()
+		if err != nil { //产生了panic异常
+			errStr, ok := err.(string)
+			if ok && errStr == message {
+				return
+			}
+		}
+		t.Errorf(fmt.Sprintf("TestRouterAddRouterMethodPanicNotImplementInterface failed: %v", err))
+	}()
+
+	handler := NewControllerRegister()
+	handler.AddRouterMethod(method, "/user", TestControllerWithInterface.Ping)
+}
--- a/server/web/server.go
+++ b/server/web/server.go
@ -463,6 +463,166 @@ func (app *HttpServer) AutoPrefix(prefix string, c ControllerInterface) *HttpSer
 	return app
 }

+// RouterGet see HttpServer.RouterGet
+func RouterGet(rootpath string, f interface{}) {
+	BeeApp.RouterGet(rootpath, f)
+}
+
+// RouterGet used to register router for RouterGet method
+// usage:
+//    type MyController struct {
+//	     web.Controller
+//    }
+//    func (m MyController) Ping() {
+//	     m.Ctx.Output.Body([]byte("hello world"))
+//    }
+//
+//    RouterGet("/api/:id", MyController.Ping)
+func (app *HttpServer) RouterGet(rootpath string, f interface{}) *HttpServer {
+	app.Handlers.RouterGet(rootpath, f)
+	return app
+}
+
+// RouterPost see HttpServer.RouterGet
+func RouterPost(rootpath string, f interface{}) {
+	BeeApp.RouterPost(rootpath, f)
+}
+
+// RouterPost used to register router for RouterPost method
+// usage:
+//    type MyController struct {
+//	     web.Controller
+//    }
+//    func (m MyController) Ping() {
+//	     m.Ctx.Output.Body([]byte("hello world"))
+//    }
+//
+//    RouterPost("/api/:id", MyController.Ping)
+func (app *HttpServer) RouterPost(rootpath string, f interface{}) *HttpServer {
+	app.Handlers.RouterPost(rootpath, f)
+	return app
+}
+
+// RouterHead see HttpServer.RouterHead
+func RouterHead(rootpath string, f interface{}) {
+	BeeApp.RouterHead(rootpath, f)
+}
+
+// RouterHead used to register router for RouterHead method
+// usage:
+//    type MyController struct {
+//	     web.Controller
+//    }
+//    func (m MyController) Ping() {
+//	     m.Ctx.Output.Body([]byte("hello world"))
+//    }
+//
+//    RouterHead("/api/:id", MyController.Ping)
+func (app *HttpServer) RouterHead(rootpath string, f interface{}) *HttpServer {
+	app.Handlers.RouterHead(rootpath, f)
+	return app
+}
+
+// RouterPut see HttpServer.RouterPut
+func RouterPut(rootpath string, f interface{}) {
+	BeeApp.RouterPut(rootpath, f)
+}
+
+// RouterPut used to register router for RouterPut method
+// usage:
+//    type MyController struct {
+//	     web.Controller
+//    }
+//    func (m MyController) Ping() {
+//	     m.Ctx.Output.Body([]byte("hello world"))
+//    }
+//
+//    RouterPut("/api/:id", MyController.Ping)
+func (app *HttpServer) RouterPut(rootpath string, f interface{}) *HttpServer {
+	app.Handlers.RouterPut(rootpath, f)
+	return app
+}
+
+// RouterPatch see HttpServer.RouterPatch
+func RouterPatch(rootpath string, f interface{}) {
+	BeeApp.RouterPatch(rootpath, f)
+}
+
+// RouterPatch used to register router for RouterPatch method
+// usage:
+//    type MyController struct {
+//	     web.Controller
+//    }
+//    func (m MyController) Ping() {
+//	     m.Ctx.Output.Body([]byte("hello world"))
+//    }
+//
+//    RouterPatch("/api/:id", MyController.Ping)
+func (app *HttpServer) RouterPatch(rootpath string, f interface{}) *HttpServer {
+	app.Handlers.RouterPatch(rootpath, f)
+	return app
+}
+
+// RouterDelete see HttpServer.RouterDelete
+func RouterDelete(rootpath string, f interface{}) {
+	BeeApp.RouterDelete(rootpath, f)
+}
+
+// RouterDelete used to register router for RouterDelete method
+// usage:
+//    type MyController struct {
+//	     web.Controller
+//    }
+//    func (m MyController) Ping() {
+//	     m.Ctx.Output.Body([]byte("hello world"))
+//    }
+//
+//    RouterDelete("/api/:id", MyController.Ping)
+func (app *HttpServer) RouterDelete(rootpath string, f interface{}) *HttpServer {
+	app.Handlers.RouterDelete(rootpath, f)
+	return app
+}
+
+// RouterOptions see HttpServer.RouterOptions
+func RouterOptions(rootpath string, f interface{}) {
+	BeeApp.RouterOptions(rootpath, f)
+}
+
+// RouterOptions used to register router for RouterOptions method
+// usage:
+//    type MyController struct {
+//	     web.Controller
+//    }
+//    func (m MyController) Ping() {
+//	     m.Ctx.Output.Body([]byte("hello world"))
+//    }
+//
+//    RouterOptions("/api/:id", MyController.Ping)
+func (app *HttpServer) RouterOptions(rootpath string, f interface{}) *HttpServer {
+	app.Handlers.RouterOptions(rootpath, f)
+	return app
+}
+
+// RouterAny see HttpServer.RouterAny
+func RouterAny(rootpath string, f interface{}) {
+	BeeApp.RouterAny(rootpath, f)
+}
+
+// RouterAny used to register router for RouterAny method
+// usage:
+//    type MyController struct {
+//	     web.Controller
+//    }
+//    func (m MyController) Ping() {
+//	     m.Ctx.Output.Body([]byte("hello world"))
+//    }
+//
+//    RouterAny("/api/:id", MyController.Ping)
+func (app *HttpServer) RouterAny(rootpath string, f interface{}) *HttpServer {
+	app.Handlers.RouterAny(rootpath, f)
+	return app
+}
+
 // Get see HttpServer.Get
 func Get(rootpath string, f FilterFunc) *HttpServer {
 	return BeeApp.Get(rootpath, f)
--- a/server/web/server_test.go
+++ b/server/web/server_test.go
@ -15,6 +15,8 @@
 package web

 import (
+	"net/http"
+	"net/http/httptest"
 	"testing"

 	"github.com/stretchr/testify/assert"
@ -28,3 +30,82 @@ func TestNewHttpServerWithCfg(t *testing.T) {
 	assert.Equal(t, "hello", BConfig.AppName)

 }
+
+func TestServerRouterGet(t *testing.T) {
+	r, _ := http.NewRequest(http.MethodGet, "/user", nil)
+	w := httptest.NewRecorder()
+
+	RouterGet("/user", ExampleController.Ping)
+	BeeApp.Handlers.ServeHTTP(w, r)
+	if w.Body.String() != exampleBody {
+		t.Errorf("TestServerRouterGet can't run")
+	}
+}
+
+func TestServerRouterPost(t *testing.T) {
+	r, _ := http.NewRequest(http.MethodPost, "/user", nil)
+	w := httptest.NewRecorder()
+
+	RouterPost("/user", ExampleController.Ping)
+	BeeApp.Handlers.ServeHTTP(w, r)
+	if w.Body.String() != exampleBody {
+		t.Errorf("TestServerRouterPost can't run")
+	}
+}
+
+func TestServerRouterHead(t *testing.T) {
+	r, _ := http.NewRequest(http.MethodHead, "/user", nil)
+	w := httptest.NewRecorder()
+
+	RouterHead("/user", ExampleController.Ping)
+	BeeApp.Handlers.ServeHTTP(w, r)
+	if w.Body.String() != exampleBody {
+		t.Errorf("TestServerRouterHead can't run")
+	}
+}
+
+func TestServerRouterPut(t *testing.T) {
+	r, _ := http.NewRequest(http.MethodPut, "/user", nil)
+	w := httptest.NewRecorder()
+
+	RouterPut("/user", ExampleController.Ping)
+	BeeApp.Handlers.ServeHTTP(w, r)
+	if w.Body.String() != exampleBody {
+		t.Errorf("TestServerRouterPut can't run")
+	}
+}
+
+func TestServerRouterPatch(t *testing.T) {
+	r, _ := http.NewRequest(http.MethodPatch, "/user", nil)
+	w := httptest.NewRecorder()
+
+	RouterPatch("/user", ExampleController.Ping)
+	BeeApp.Handlers.ServeHTTP(w, r)
+	if w.Body.String() != exampleBody {
+		t.Errorf("TestServerRouterPatch can't run")
+	}
+}
+
+func TestServerRouterDelete(t *testing.T) {
+	r, _ := http.NewRequest(http.MethodDelete, "/user", nil)
+	w := httptest.NewRecorder()
+
+	RouterDelete("/user", ExampleController.Ping)
+	BeeApp.Handlers.ServeHTTP(w, r)
+	if w.Body.String() != exampleBody {
+		t.Errorf("TestServerRouterDelete can't run")
+	}
+}
+
+func TestServerRouterAny(t *testing.T) {
+	RouterAny("/user", ExampleController.Ping)
+
+	for method := range HTTPMETHOD {
+		r, _ := http.NewRequest(method, "/user", nil)
+		w := httptest.NewRecorder()
+		BeeApp.Handlers.ServeHTTP(w, r)
+		if w.Body.String() != exampleBody {
+			t.Errorf("TestServerRouterAny can't run")
+		}
+	}
+}