Bereitstellung von statischem Inhalt mit einer Stamm-URL mit dem Gorilla-Toolkit

Question

Ich versuche, das Gorilla-Toolkit mux package zu verwenden, um URLs auf einem Go-Webserver zu routen. Mit this question als Leitfaden ich folgende Go-Code haben:

func main() { 
    r := mux.NewRouter() 
    r.Handle("/", http.FileServer(http.Dir("./static/"))) 
    r.HandleFunc("/search/{searchTerm}", Search) 
    r.HandleFunc("/load/{dataId}", Load) 
    http.Handle("/", r) 
    http.ListenAndServe(":8100", nil) 
} 

Die Verzeichnisstruktur ist:

... 
main.go 
static\ 
    | index.html 
    | js\ 
    | <js files> 
    | css\ 
    | <css files> 

Die Javascript und CSS-Dateien werden in index.html wie folgt verwiesen:

... 
<link rel="stylesheet" href="css/redmond/jquery-ui.min.css"/> 
<script src="js/jquery.min.js"></script> 
... 

Als ich http://localhost:8100 in meinem Web-Browser Zugriff auf den index.html Inhalt erfolgreich geliefert, aber alle die js und css URLs geben 404s zurück.

Wie bekomme ich das Programm, um Dateien aus static Unterverzeichnissen zu liefern?

Answer 1

Ich glaube, Sie könnten für PathPrefix suchen ...

func main() { 
    r := mux.NewRouter() 
    r.HandleFunc("/search/{searchTerm}", Search) 
    r.HandleFunc("/load/{dataId}", Load) 
    r.PathPrefix("/").Handler(http.FileServer(http.Dir("./static/"))) 
    http.Handle("/", r) 
    http.ListenAndServe(":8100", nil) 
} 

Answer 2

Versuchen Sie folgendes:

fileHandler := http.StripPrefix("/static/", http.FileServer(http.Dir("/absolute/path/static"))) 
http.Handle("/static/", fileHandler) 

Answer 3

Nach viel Versuch und Irrtum, beide oben genannten Antworten half mir in den kommenden up mit dem, was hat für mich gearbeitet. Ich habe einen statischen Ordner im Stammverzeichnis der Web-App.

Zusammen mit PathPrefix musste ich StripPrefix für die Route zu rekursiv arbeiten verwenden.

package main 

import (
    "log" 
    "net/http" 
    "github.com/gorilla/mux" 
) 

func main() { 
    r := mux.NewRouter() 
    s := http.StripPrefix("/static/", http.FileServer(http.Dir("./static/"))) 
    r.PathPrefix("/static/").Handler(s) 
    http.Handle("/", r) 
    err := http.ListenAndServe(":8081", nil) 
} 

Ich hoffe, es hilft jemand anderen Probleme haben.

Answer 4

Ich habe diesen Code hier, die sehr schön und ist wiederverwendbar funktioniert.

func ServeStatic(router *mux.Router, staticDirectory string) { 
    staticPaths := map[string]string{ 
     "styles":   staticDirectory + "/styles/", 
     "bower_components": staticDirectory + "/bower_components/", 
     "images":   staticDirectory + "/images/", 
     "scripts":   staticDirectory + "/scripts/", 
    } 
    for pathName, pathValue := range staticPaths { 
     pathPrefix := "/" + pathName + "/" 
     router.PathPrefix(pathPrefix).Handler(http.StripPrefix(pathPrefix, 
      http.FileServer(http.Dir(pathValue)))) 
    } 
} 
router := mux.NewRouter() 
ServeStatic(router, "/static/") 

Answer 5

Dies dient alle Dateien innerhalb der Ordner-Flag sowie serving Index.html im Stammverzeichnis.

Nutzungs

//port default values is 8500 
    //folder defaults to the current directory 
    go run main.go 

    //your case, dont forget the last slash 
    go run main.go -folder static/ 

    //dont 
    go run main.go -folder ./ 

-Code

package main 

import (
    "flag" 
    "fmt" 
    "net/http" 
    "os" 
    "strconv" 
    "strings" 

    "github.com/gorilla/handlers" 
    "github.com/gorilla/mux" 
    "github.com/kr/fs" 
) 

func main() { 
    mux := mux.NewRouter() 

    var port int 
    var folder string 
    flag.IntVar(&port, "port", 8500, "help message for port") 
    flag.StringVar(&folder, "folder", "", "help message for folder") 

    flag.Parse() 

    walker := fs.Walk("./" + folder) 
    for walker.Step() { 
     var www string 

     if err := walker.Err(); err != nil { 
      fmt.Fprintln(os.Stderr, "eroooooo") 
      continue 
     } 
     www = walker.Path() 
     if info, err := os.Stat(www); err == nil && !info.IsDir() { 
      mux.HandleFunc("/"+strings.Replace(www, folder, "", -1), func(w http.ResponseWriter, r *http.Request) { 
       http.ServeFile(w, r, www) 
      }) 
     } 
    } 
    mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) { 
     http.ServeFile(w, r, folder+"index.html") 
    }) 
    http.ListenAndServe(":"+strconv.Itoa(port), handlers.LoggingHandler(os.Stdout, mux)) 
}