Merge pull request #97 from devfeel/develop

Develop - dotweb新增ExcludeUse接口，重构Middleware实现

Author: devfeel

context.go

@@ -87,24 +87,25 @@ type (
 	HttpContext struct {
 		context context.Context
 		//暂未启用
-		cancle       context.CancelFunc
-		request      *Request
-		routerNode   RouterNode
-		routerParams Params
-		response     *Response
-		webSocket    *WebSocket
-		hijackConn   *HijackConn
-		isWebSocket  bool
-		isHijack     bool
-		isEnd        bool //表示当前处理流程是否需要终止
-		httpServer   *HttpServer
-		sessionID    string
-		innerItems   *core.ItemContext
-		items        *core.ItemContext
-		viewData     *core.ItemContext
-		features     *xFeatureTools
-		handler      HttpHandle
-		startTime    time.Time
+		cancle         context.CancelFunc
+		middlewareStep string
+		request        *Request
+		routerNode     RouterNode
+		routerParams   Params
+		response       *Response
+		webSocket      *WebSocket
+		hijackConn     *HijackConn
+		isWebSocket    bool
+		isHijack       bool
+		isEnd          bool //表示当前处理流程是否需要终止
+		httpServer     *HttpServer
+		sessionID      string
+		innerItems     *core.ItemContext
+		items          *core.ItemContext
+		viewData       *core.ItemContext
+		features       *xFeatureTools
+		handler        HttpHandle
+		startTime      time.Time
 	}
 )
 
@@ -129,6 +130,7 @@ func (ctx *HttpContext) reset(res *Response, r *Request, server *HttpServer, nod
 func (ctx *HttpContext) release() {
 	ctx.request = nil
 	ctx.response = nil
+	ctx.middlewareStep = ""
 	ctx.routerNode = nil
 	ctx.routerParams = nil
 	ctx.webSocket = nil

dotweb.go

@@ -54,7 +54,6 @@ const (
 	RunMode_Production  = "production"
 )
 
-
 //New create and return DotApp instance
 func New() *DotWeb {
 	app := &DotWeb{
@@ -141,6 +140,19 @@ func (app *DotWeb) SetProductionMode() {
 	logger.SetEnabledConsole(false)
 }
 
+// ExcludeUse registers a middleware exclude routers
+// like exclude /index or /query/:id
+func (app *DotWeb) ExcludeUse(m Middleware, routers ...string) {
+	middlewareLen := len(app.Middlewares)
+	if m != nil {
+		m.Exclude(routers...)
+		if middlewareLen > 0 {
+			app.Middlewares[middlewareLen-1].SetNext(m)
+		}
+		app.Middlewares = append(app.Middlewares, m)
+	}
+}
+
 // Use registers a middleware
 func (app *DotWeb) Use(m ...Middleware) {
 	step := len(app.Middlewares) - 1
@@ -244,10 +256,14 @@ func (app *DotWeb) MustStart() {
 // not support pprof server auto start
 func (app *DotWeb) ListenAndServe(addr string) error {
 	app.initAppConfig()
-	app.initRegisterMiddleware()
-	app.initRegisterRoute()
-	app.initRegisterGroup()
+	app.initRegisterConfigMiddleware()
+	app.initRegisterConfigRoute()
+	app.initRegisterConfigGroup()
+
 	app.initServerEnvironment()
+
+	app.initBindMiddleware()
+
 	app.initInnerRouter()
 
 	if app.HttpServer.ServerConfig().EnabledTLS {
@@ -300,8 +316,8 @@ func (app *DotWeb) initAppConfig() {
 	}
 }
 
-// init register Middleware
-func (app *DotWeb) initRegisterMiddleware() {
+// init register config's Middleware
+func (app *DotWeb) initRegisterConfigMiddleware() {
 	config := app.Config
 	//register app's middleware
 	for _, m := range config.Middlewares {
@@ -314,8 +330,8 @@ func (app *DotWeb) initRegisterMiddleware() {
 	}
 }
 
-// init register route
-func (app *DotWeb) initRegisterRoute() {
+// init register config's route
+func (app *DotWeb) initRegisterConfigRoute() {
 	config := app.Config
 	//load router and register
 	for _, r := range config.Routers {
@@ -335,8 +351,8 @@ func (app *DotWeb) initRegisterRoute() {
 	}
 }
 
-// init register route
-func (app *DotWeb) initRegisterGroup() {
+// init register config's route
+func (app *DotWeb) initRegisterConfigGroup() {
 	config := app.Config
 	//support group
 	for _, v := range config.Groups {
@@ -371,6 +387,23 @@ func (app *DotWeb) initRegisterGroup() {
 	}
 }
 
+// init bind app's middleware to router node
+func (app *DotWeb) initBindMiddleware() {
+	//add default httphandler with middlewares
+	app.Use(&xMiddleware{})
+
+	router := app.HttpServer.Router().(*router)
+	for path, node := range router.allNodeMap {
+		logger.Logger().Debug("DotWeb initBindMiddleware "+path+" "+fmt.Sprint(node), LogTarget_HttpServer)
+		node.appMiddlewares = app.Middlewares
+		for _, m := range node.appMiddlewares {
+			if m.HasExclude() && m.ExistsExcludeRouter(node.fullPath) {
+				node.hasExcludeMiddleware = true
+			}
+		}
+	}
+}
+
 // init inner routers
 func (app *DotWeb) initInnerRouter() {
 	//默认支持pprof信息查看
@@ -416,9 +449,6 @@ func (app *DotWeb) initServerEnvironment() {
 		app.HttpServer.SetRenderer(NewInnerRenderer())
 	}
 
-	//add default httphandler with middlewares
-	app.Use(&xMiddleware{})
-
 	//start pprof server
 	if app.Config.App.EnabledPProf {
 		logger.Logger().Debug("DotWeb:StartPProfServer["+strconv.Itoa(app.Config.App.PProfPort)+"] Begin", LogTarget_HttpServer)

example/middleware/main.go

@@ -27,11 +27,11 @@ func main() {
 
 	//InitModule(app)
 
-	app.UseRequestLog()
+	//app.UseRequestLog()
 	app.Use(
 		NewAccessFmtLog("app"),
-	//NewSimpleAuth("admin"),
 	)
+	app.ExcludeUse(NewAccessFmtLog("appex"), "/", "/")
 
 	//启动 监控服务
 	app.SetPProfConfig(true, 8081)
@@ -51,6 +51,7 @@ func Index(ctx dotweb.Context) error {
 	ctx.Response().Header().Set("Content-Type", "text/html; charset=utf-8")
 	//fmt.Println(time.Now(), "Index Handler")
 	_, err := ctx.WriteString("index  => ", fmt.Sprint(ctx.RouterNode().Middlewares()))
+	fmt.Println(ctx.RouterNode().GroupMiddlewares())
 	return err
 }
 

group.go

@@ -30,7 +30,19 @@ func NewGroup(prefix string, server *HttpServer) Group {
 
 // Use implements `Router#Use()` for sub-routes within the Group.
 func (g *xGroup) Use(m ...Middleware) Group {
-	g.middlewares = append(g.middlewares, m...)
+	if len(m) <= 0 {
+		return g
+	}
+	step := len(g.middlewares) - 1
+	for i := range m {
+		if m[i] != nil {
+			if step >= 0 {
+				g.middlewares[step].SetNext(m[i])
+			}
+			g.middlewares = append(g.middlewares, m[i])
+			step++
+		}
+	}
 	return g
 }
 
@@ -79,6 +91,7 @@ func (g *xGroup) RegisterRoute(method, path string, handler HttpHandle) RouterNo
 }
 
 func (g *xGroup) add(method, path string, handler HttpHandle) RouterNode {
-	node := g.server.Router().RegisterRoute(method, g.prefix+path, handler).Use(g.middlewares...)
+	node := g.server.Router().RegisterRoute(method, g.prefix+path, handler)
+	node.Node().groupMiddlewares = g.middlewares
 	return node
 }

middleware.go

@@ -3,30 +3,105 @@ package dotweb
 import (
 	"github.com/devfeel/dotweb/framework/convert"
 	"github.com/devfeel/dotweb/logger"
-	"reflect"
 	"time"
 )
 
+const (
+	middleware_App    = "app"
+	middleware_Group  = "group"
+	middleware_Router = "router"
+)
+
 type MiddlewareFunc func() Middleware
 
+//middleware执行优先级：
+//优先级1：app级别middleware
+//优先级2：group级别middleware
+//优先级3：router级别middleware
+
 // Middleware middleware interface
 type Middleware interface {
 	Handle(ctx Context) error
 	SetNext(m Middleware)
 	Next(ctx Context) error
+	Exclude(routers ...string)
+	HasExclude() bool
+	ExistsExcludeRouter(router string) bool
 }
 
 //middleware 基础类，应用可基于此实现完整Moddleware
 type BaseMiddlware struct {
-	next Middleware
+	next           Middleware
+	excludeRouters map[string]struct{}
 }
 
 func (bm *BaseMiddlware) SetNext(m Middleware) {
 	bm.next = m
 }
 
 func (bm *BaseMiddlware) Next(ctx Context) error {
-	return bm.next.Handle(ctx)
+	httpCtx := ctx.(*HttpContext)
+	if httpCtx.middlewareStep == "" {
+		httpCtx.middlewareStep = middleware_App
+	}
+	if bm.next == nil {
+		if httpCtx.middlewareStep == middleware_App {
+			httpCtx.middlewareStep = middleware_Group
+			if len(httpCtx.RouterNode().GroupMiddlewares()) > 0 {
+				return httpCtx.RouterNode().GroupMiddlewares()[0].Handle(ctx)
+			}
+		}
+		if httpCtx.middlewareStep == middleware_Group {
+			httpCtx.middlewareStep = middleware_Router
+			if len(httpCtx.RouterNode().Middlewares()) > 0 {
+				return httpCtx.RouterNode().Middlewares()[0].Handle(ctx)
+			}
+		}
+
+		if httpCtx.middlewareStep == middleware_Router {
+			return httpCtx.Handler()(ctx)
+		}
+	} else {
+		//check exclude config
+		if ctx.RouterNode().Node().hasExcludeMiddleware && bm.next.HasExclude() {
+			if bm.next.ExistsExcludeRouter(ctx.RouterNode().Node().fullPath) {
+				return bm.next.Next(ctx)
+			}
+		}
+		return bm.next.Handle(ctx)
+	}
+	return nil
+}
+
+// Exclude Exclude this middleware with router
+func (bm *BaseMiddlware) Exclude(routers ...string) {
+	if bm.excludeRouters == nil {
+		bm.excludeRouters = make(map[string]struct{})
+	}
+	for _, v := range routers {
+		bm.excludeRouters[v] = struct{}{}
+	}
+}
+
+// HasExclude check has set exclude router
+func (bm *BaseMiddlware) HasExclude() bool {
+	if bm.excludeRouters == nil {
+		return false
+	}
+	if len(bm.excludeRouters) > 0 {
+		return true
+	} else {
+		return false
+	}
+}
+
+// ExistsExcludeRouter check is exists router in exclude map
+func (bm *BaseMiddlware) ExistsExcludeRouter(router string) bool {
+	if bm.excludeRouters == nil {
+		return false
+	}
+	_, exists := bm.excludeRouters[router]
+	return exists
 }
 
 type xMiddleware struct {
@@ -35,24 +110,14 @@ type xMiddleware struct {
 }
 
 func (x *xMiddleware) Handle(ctx Context) error {
-	len := len(ctx.RouterNode().Middlewares())
+	httpCtx := ctx.(*HttpContext)
+	if httpCtx.middlewareStep == "" {
+		httpCtx.middlewareStep = middleware_App
+	}
 	if x.IsEnd {
-		return ctx.Handler()(ctx)
-	} else {
-		if x.next == nil {
-			if len <= 0 {
-				return ctx.Handler()(ctx)
-			} else {
-				if reflect.TypeOf(ctx.RouterNode().Middlewares()[len-1]).String() != "*dotweb.xMiddleware" {
-					ctx.RouterNode().Use(&xMiddleware{IsEnd: true})
-				}
-				return ctx.RouterNode().Middlewares()[0].Handle(ctx)
-			}
-		} else {
-			return x.Next(ctx)
-		}
+		return httpCtx.Handler()(ctx)
 	}
-
+	return x.Next(ctx)
 }
 
 //请求日志中间件