Elaborazione di contenuto statico con un URL radice con il toolkit Gorilla

Question

Sto tentando di utilizzare il toolkit Gorilla mux package per indirizzare gli URL in un server Web Go. Utilizzando this question come guida ho il seguente codice Go:

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) 
} 

La struttura di directory è:

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

Il Javascript e file CSS si fa riferimento in index.html come questo:

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

Quando accedo allo http://localhost:8100 nel browser Web, il contenuto dello index.html viene consegnato correttamente, tuttavia, tutti gliGli URLe css restituiscono 404 secondi.

Come è possibile ottenere il programma per servire i file delle sottodirectory static?

Answer 1

Penso che potrebbe essere alla ricerca di PathPrefix ...

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

Prova questo:

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

Answer 3

Dopo un sacco di tentativi ed errori, entrambe le risposte di cui sopra mi ha aiutato a venire con quello che ha funzionato per me Ho una cartella statica nella directory principale dell'app web.

Insieme a PathPrefix ho dovuto utilizzare StripPrefix per ottenere il percorso di lavoro in modo ricorsivo.

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) 
} 

Spero che aiuti qualcun altro a riscontrare problemi.

Answer 4

Ho qui questo codice che funziona abbastanza bene ed è riutilizzabile.

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

Questo serve tutti i file all'interno del flag di cartella, oltre a servire index.html nella radice.

Uso

//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 ./ 

Codice

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)) 
}