Golang web.Mux类代码示例

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 router(m *web.Mux) http.Handler {
	m.Get("/", UserRoot)
	user := web.New()
	goji.Handle("/user/*", user)
	user.Use(middleware.SubRouter)
	user.Get("/", 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
}

// Sets up the routes
func (api *Api) Route(m *web.Mux) {

	m.Get("/:topic/:username", api.NextMessage)
	m.Post("/:topic/:username", api.SubscribeToTopic)
	m.Delete("/:topic/:username", api.UnsubscribeFromTopic)

	m.Post("/:topic", api.PublishMessage)

}

// attach r.Handler and r.Method to the correct verb function
func getHandler(wm *web.Mux, r *Route) error {
	switch strings.ToLower(r.Method) {
	case "get":
		wm.Get(r.Pattern, r.Handler)
	case "post":
		wm.Post(r.Pattern, r.Handler)
	case "put":
		wm.Put(r.Pattern, r.Handler)
	case "patch":
		wm.Patch(r.Pattern, r.Handler)
	case "delete":
		wm.Delete(r.Pattern, r.Handler)
	default:
		return errors.New("unsupported method: " + r.Method)
	}

	return nil
}

// SetupMainServer allocates a listener socket and starts a web server with graceful restart
// on the specified IP address and port. The ipPort has the format "ip_address:port" or
// ":port" for 0.0.0.0/port.
func SetupMainServer(ipPort string, mux *web.Mux) {
	listener, err := net.Listen("tcp4", ipPort)
	if err != nil {
		FatalError(err.Error())
	}

	// Install our handler at the root of the standard net/http default mux.
	// This allows packages like expvar to continue working as expected.
	mux.Compile()
	http.Handle("/", mux)

	graceful.HandleSignals()
	graceful.PreHook(func() { log15.Warn("Gracefully stopping on signal") })
	graceful.PostHook(func() { log.Printf("Gracefully stopped") })

	err = graceful.Serve(listener, http.DefaultServeMux)
	if err != nil {
		FatalError(err.Error())
	}

	graceful.Wait()
}

func Add(mux *web.Mux) {

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

}

func route(m *web.Mux) {

	resultMux := web.New()
	resultMux.Get("/face_detect/:name", http.StripPrefix("/face_detect/", http.FileServer(http.Dir("./results/"))))
	resultMux.Use(renameID)

	m.Handle("/face_detect/:name", resultMux)
	m.Get(toolURI, controllers.ControllPannel)
	m.Post(toolURI, controllers.RegisterFace)
}

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
}

// Route configures routing. it is also used in test-code
func Route(m *web.Mux) {

	m.Get("/hello/:name", hello)
	m.Get("/", root)
}

// example handler
func AddHandlers(mux *web.Mux) {
	mux.Get("/api/xxxx", hello)
}

func route(m *web.Mux) {
	m.Get("/hello/:name", hello)
}

func Bookmarks(m *web.Mux) {
	goji.Handle("/bookmarks/*", m)
	goji.Get("/bookmarks", http.RedirectHandler("/bookmarks/", 301))

	m.Get("/bookmarks/", controllers.BookmarksHome)
}

func setRoutes(mux *web.Mux, sde evego.Database, localdb db.LocalDB, xmlAPI evego.XMLAPI,
	eveCentral evego.Market, sessionizer server.Sessionizer, cache evego.Cache) {

	if c.Dev {
		bower := http.FileServer(http.Dir("bower_components"))
		mux.Get("/bower_components/*", http.StripPrefix("/bower_components/", bower))
	}

	mux.Get("/autocomplete/system/:name", api.AutocompleteSystems(sde))
	mux.Get("/autocomplete/station/:name", api.AutocompleteStations(sde, localdb, xmlAPI))
	mux.Post("/pastebin", api.ParseItems(sde))
	marketHandler := api.ItemsMarketValue(sde, eveCentral, xmlAPI)
	// For now these do the same thing. That may change.
	mux.Post("/market/region/:location", marketHandler)
	mux.Post("/market/system/:location", marketHandler)
	mux.Post("/market/station/:id", marketHandler)
	mux.Get("/market/jita", api.ReprocessOutputValues(sde, eveCentral, xmlAPI, cache))

	mux.Post("/reprocess", api.ReprocessItems(sde, eveCentral))
	// SSO!
	auth := evesso.MakeAuthenticator(evesso.Endpoint, c.ClientID, c.ClientSecret,
		c.RedirectURL, evesso.PublicData)
	mux.Get("/crestcallback", api.CRESTCallbackListener(localdb, auth, sessionizer))
	mux.Get("/authenticate", api.AuthenticateHandler(auth, sessionizer))
	mux.Get("/session", api.SessionInfo(auth, sessionizer, localdb))
	mux.Post("/logout", api.LogoutHandler(localdb, auth, sessionizer))

	// API keys
	listHandler, deleteHander, addHandler, refreshHandler := api.XMLAPIKeysHandlers(localdb, sessionizer)
	mux.Get("/apikeys/list", listHandler)
	mux.Post("/apikeys/delete/:keyid", deleteHander)
	mux.Post("/apikeys/add", addHandler)
	mux.Post("/apikeys/refresh", refreshHandler)

	// Standings and skills
	mux.Get("/standings/:charID/:npcCorpID", api.StandingsHandler(localdb, sessionizer))
	mux.Get("/skills/:charID/group/:skillGroupID", api.SkillsHandler(localdb, sessionizer))

	// Blueprints and industry
	_, getBPs := api.BlueprintsHandlers(localdb, sde, sessionizer)
	mux.Get("/blueprints/:charID", getBPs)
	mux.Get("/assets/unusedSalvage/:charID", api.UnusedSalvage(localdb, sde, sessionizer))

	// Static assets
	assets := http.FileServer(http.Dir("dist"))
	mux.Get("/*", assets)
}

func RootRouter(m *web.Mux) {
	m.Get("/", Root)
}

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

	m.Get("/admin/", ad.AdminIndex)

	m.Get("/user/index", cntr.UserIndex)
	m.Post("/user/add", cntr.UserAdd)
	m.Post("/user/auth", cntr.UserAuth)

	m.Get("/player/joblist", cntr.JobList)
	m.Post("/player/joblist", cntr.JobList)
	m.Get("/player/base_make", cntr.PlayerBaseMake)
	m.Post("/player/base_make", cntr.PlayerBaseMake)
	m.Post("/player/generate", cntr.PlayerGenerate)
	m.Post("/player/skill_setting", cntr.SkillSetting)
	m.Post("/player/skill_submit", cntr.SkillSubmit)

	m.Post("/home/user/info", cntr.UserInfo)
	m.Get("/home/scenario/list", cntr.ScenarioList)
	m.Post("/home/player/list", cntr.PlayerList)

	return m
}