Golang Mux.Use方法代码示例

func Add(mux *web.Mux) {

	/* Endpoint to handler config */
	mux.Get("/", home)
	mux.Get("/home", about)
	mux.Use(mux.Router)

}

func rooter(m *web.Mux) http.Handler {
	m.Use(SuperSecure)
	m.Get("/index", UserRoot)
	m.Get("/user/index", UserIndex)
	m.Get("/user/new", UserNew)
	m.Post("/user/new", UserCreate)
	m.Get("/user/edit/:id", UserEdit)
	m.Post("/user/update/:id", UserUpdate)
	m.Get("/user/delete/:id", UserDelete)

	return m
}

func route(m *web.Mux) {
	// Add routes to the global handler
	setGetHandler(m, "/", Root)
	// Use Sinatra-style patterns in your URLs
	setGetHandler(m, "/novel/:ncode", responseCache(getNovelInfo))
	setGetHandler(m, "/novel_content/:ncode/:sublist_id", responseCache(getNovelContent))

	// Middleware can be used to inject behavior into your app. The
	// middleware for this application are defined in middleware.go, but you
	// can put them wherever you like.
	m.Use(Json)
}

func rooter(m *web.Mux) http.Handler {
	m.Use(SuperSecure)

	user := web.New()
	goji.Handle("/user/*", user)
	user.Use(middleware.SubRouter)
	user.Get("/index", UserIndex)
	user.Get("/new", UserNew)
	user.Post("/new", UserCreate)
	user.Get("/edit/:id", UserEdit)
	user.Post("/update/:id", UserUpdate)
	user.Get("/delete/:id", UserDelete)

	return m
}

func (rm *RouterMold) Generate() *web.Mux {
	var mux *web.Mux
	if rm.SubRoutes == "" {
		mux = goji.DefaultMux
		mux.Abandon(middleware.Logger)
	} else {
		mux := web.New()
		mux.Use(middleware.RequestID)
		mux.Use(middleware.Recoverer)
		mux.Use(middleware.AutomaticOptions)
		goji.Handle(rm.SubRoutes, mux)
	}

	for _, m := range rm.Middlewares {
		mux.Use(m.MiddlewareFunc())
	}

	var handlerFunc func(Route) interface{}
	if rm.HandlerFunc == nil {
		handlerFunc = func(r Route) interface{} {
			return r.Handler
		}
	} else {
		handlerFunc = rm.HandlerFunc
	}

	for _, r := range rm.Routes {
		var pattern interface{}
		if r.RegExp != "" {
			pattern = regexp.MustCompile(r.RegExp)
		} else {
			pattern = r.Path
		}
		switch r.Method {
		case "HEAD":
			mux.Head(pattern, handlerFunc(r))
		case "GET":
			mux.Get(pattern, handlerFunc(r))
		case "POST":
			mux.Post(pattern, handlerFunc(r))
		case "PUT":
			mux.Put(pattern, handlerFunc(r))
		case "PATCH":
			mux.Patch(pattern, handlerFunc(r))
		case "DELETE":
			mux.Delete(pattern, handlerFunc(r))
		}
	}

	return mux
}

// This demo file shows two ways to test the handlers, it is not suggested to use both in a real
// project, the two methods are provided here as a sample.

// Tests that simply create a mux and exercise that by calling the Mux's ServeHTTP function
// This is great for isolated tests, it becomes difficult when the middleware higher in the stack
// is needed or other concurrent goroutines and other handlers al also needed for higher-level tests
var _ = Describe("Mux-based settings tests", func() {

	var mx *web.Mux // mux with the handlers we're testing

	BeforeEach(func() {
		settings = make(map[string]string)
		mx = NewMux()
		gojiutil.AddCommon15(mx, log15.Root())
		mx.Use(gojiutil.ParamsLogger(true)) // useful for troubleshooting
	})

	It("gets what it sets", func() {
		// set a value
		req, _ := http.NewRequest("PUT", "http://example.com/settings/hello?value=world",
			bytes.NewReader([]byte{}))
		resp := httptest.NewRecorder()
		mx.ServeHTTP(resp, req)
		Ω(resp.Code).Should(Equal(200))
		Ω(settings["hello"]).Should(Equal("world"))

		// get the value back
		req, _ = http.NewRequest("GET", "http://example.com/settings/hello", nil)
		resp = httptest.NewRecorder()
		mx.ServeHTTP(resp, req)