10
votes

Le routeur de Gorilla Mux imbriqué ne fonctionne pas

Utilisation du code ci-dessous, lorsque j'accède / test2 il répond avec 404 - non trouvé. / Test1 fonctionne correctement. Pourquoi donc? La nidification n'est pas autorisée malgré le fait que les routeurs impliquent l'interface http.handler? xxx pré>

EDIT: stry> p>

Mon objectif principal était d'ajouter une initiale Travaux qui seraient communs pour tous les itinéraires du sous-sortrique et pour eux seulement. Pour être encore plus spécifique, j'aimerais utiliser Negroni en tant que middleware Orchiestrator. Sur le site Web de Negoni, il existe un exemple d'ajout de middleware au groupe d'itinéraires: P>

router := mux.NewRouter()
adminRoutes := mux.NewRouter()
// add admin routes here

Create a new negroni for the admin middleware
router.Handle("/admin", negroni.New(
  Middleware1, 
  Middleware2, 
  negroni.Wrap(adminRoutes),
))

go mux gorilla

0 commentaires

4 Réponses :

6
votes

Vous n'utiliseriez pas deux routeurs ici de toute façon.

Gorilla Mux a le concept d'un code> code>, dans lequel vous définissez les propriétés du domaine de niveau supérieur sur le routeur principal, puis utilisez le Sous-routeur code> instance pour mapper les chemins individuels. P>

Par exemple: P>

mainRouter := mux.NewRouter()
subRouter := mainRouter.PathPrefix("/").Subrouter()

subRouter.HandleFunc("/test1", func(w http.ResponseWriter, r *http.Request) { fmt.Fprint(w, "test1") })
subRouter.HandleFunc("/test2", func(w http.ResponseWriter, r *http.Request) { fmt.Fprint(w, "test2") })

mainRouter.Handle("/", mainRouter)

2 commentaires

J'ai édité ma question pour être plus précis sur ce que je voulais réaliser. Je pense que le sous-titré ne résoudra pas le cas.

serait bien si vous démontrez l'autre moitié de l'exemple: / test1 / autre


                        
                                            
                            
                                
                                    12
 votes
                                
                            
                            
                                
                                     Je sais que cette question est quelque peu ancienne, mais j'ai passé un peu de temps à déterminer la façon dont les gestionnaires et les travaux correspondants sont allés. Vous pouvez voir mon code d'expérience  ici . 
 Fondamentalement, vous pouvez obtenir l'effet que vous Vous voulez avec du code comme celui-ci:   xxx  
 J'espère que cela aide quelqu'un.                                  

                                                                    
                                    
                                    
                                        1 commentaires
                                        
                                                                                            
                                                    Alors, même mille http.listenandserve est appelé avec  mainrouder ,  Sous -router  sera également inclus?                                                

                                                
                                                                                    

                                    

                                                            

                        

                        
                                            
                            
                                
                                    4
 votes
                                
                            
                            
                                
                                     Utilisez PLACEL PATH PROPERT dans les sous-routiers: 
router := mux.NewRouter()

apiRoutes := mux.NewRouter()
apiRoutes.Handle("/api/auth", Auth)

router.PathPrefix("/api").Handler(negroni.New(
  Middleware1,
  Middleware2,
  negroni.Wrap(apiRoutes),
)) 

                                

                                                                    
                                    
                                    
                                        0 commentaires
                                        
                                                                                    
                                    
                                                            
                        
                        
                                            
                            
                                
                                    8
 votes
                                
                            
                            
                                
                                     Aucune des réponses précédentes données m'a aidé à atteindre exactement ce que je cherchais à faire. J'essayais d'utiliser  negoni.wrap ()  code> autour d'un  Sous-router  code> avec beaucoup de routes. Je crois que c'est ce que l'affiche originale souhaitée. 
 Contexte supplémentaire: je suis déployé sur Google App Engine, par conséquent, mettez tout dans la fonction  init ()  code>.  P> 
package hello

import (
    "fmt"
    "net/http"

    "github.com/codegangsta/negroni"
    "github.com/gorilla/mux"
)

func init() {
    // Create the "root" router, if you will...
    r := mux.NewRouter().StrictSlash(true)

    // Create your "Subrouter" dedicated to /api which will use the PathPrefix
    apiRouter := mux.NewRouter().PathPrefix("/api").Subrouter().StrictSlash(true)

    // This step is where we connect our "root" router and our "Subrouter" together.
    r.PathPrefix("/api").Handler(negroni.New(
        negroni.HandlerFunc(myMiddleware),
        negroni.Wrap(apiRouter),
    ))

    // Define "root" routes using r
    r.HandleFunc(genHandleFunc("/", "root of site"))
    r.HandleFunc(genHandleFunc("/home", "home"))

    // Define "Subrouter" routes using apiRouter, prefix is /api
    apiRouter.HandleFunc(genHandleFunc("/", "root of API, /api"))                                       // Matches: /api
    apiRouter.HandleFunc(genHandleFunc("/v1", "root of API V1, /api/v1"))                               // Matches: /api/v1
    apiRouter.HandleFunc(genHandleFunc("/v1/resourceabc", "API V1 - resourceabc, /api/v1/resourceabc")) // Matches: /api/v1/resourceabc

    /* Finally we pass our "root" router to the net/http library. The "root" router will contain all
    of the routes for /api also.
    */
    http.Handle("/", r)
}

// Silly function to quickly generate a HandleFunc
func genHandleFunc(p string, msg string) (path string, f func(http.ResponseWriter, *http.Request)) {
    path = p
    f = func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintf(w, "%v\n", msg)
    }
    return
}

func myMiddleware(w http.ResponseWriter, r *http.Request, next http.HandlerFunc) {
    fmt.Fprintln(w, "Before doing work...")
    next(w, r)
    fmt.Fprintln(w, "After doing work...")
}

                                

                                                                    
                                    
                                    
                                        0 commentaires